﻿#define _CRT_SECURE_NO_WARNINGS   1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>


////        // 8_15  
//void test()
//{
//	int z;
//	z = x;
//	x = y;
//	y = z;
//}
//int main()
//{
//	int x = 10;
//	int y = 20;
//	test();             //并没有给函数传参
//	printf("%d%d", x, y);/
//	return 0;
//}

// 
//2、以下不正确的定义语句是（ ）
//A : double x[5] = { 2.0, 4.0, 6.0, 8.0, 10.0 };
//B: char c2[] = { '\x10', '\xa', '\8' };  //8进制不能等于8
//C: char c1[] = { '1','2','3','4','5' };
//D: int y[5 + 3] = { 0, 1, 3, 5, 7, 9 };


//test.c 文件中包括如下语句，文件中定义的四个变量中，是指针类型的变量为【多选】（ ）
//#define INT_PTR int*
//typedef int* int_ptr;
//INT_PTR a, b;  //A是 B不是
//int_ptr c, d   //C是 D是


//输入一个数   输出[1,2,3,...最大n位数]
//static int arr[100000];
//int* printNumbers(int n, int* returnSize) {
//
//    scanf("%d", &n);
//    int max = 1;
//    int i = 0;
//    for (i = 0; i < n; i++)
//    {
//        max *= 10;
//    }
//    for (i = 1; i < max; i++)  
//    {
//        arr[i - 1] = i;
//    }
//    *returnSize = i - 1;  //注意returnSize的类型是int*
//    return arr;
//}
// 
//static int arr[10000] = { 0 };//自己模拟运行
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int i = 0;
//	int max = 1;
//	for (i = 0; i < n; i++)
//	{
//		max *= 10;
//	}
//	for (i = 1; i <max; i++)
//	{
//		arr[i - 1] = i;
//	}
//	for (i = 1; i <max; i++)
//	{
//		printf("%d", arr[i-1]);
//	}
//		return 0;
//}


//计算日期到天数转化、
//年 月 日
////int main()
////{
////	int year = 0;
////	int month = 0;
////	int day = 0;
////	int sum = 0;
////	scanf("%d%d%d", &year,&month,&day);
////	if(month>2)
////	if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))//判断闰年
////		sum++;
////	int mon[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
////	while (month > 1)
////	{
////		if (year > 9999 || year < 1000 || month < 1 || month>12 || ((((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) && (mon[1])>29))
////			break;
////		sum += mon[month - 2];
////		month--;
////	}
////		sum += day;
////		printf("%d ", sum);
////	return 0;
//}
//int main()  //标答
// { int month_day[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
// int year, month, day;
// while (~scanf("%d %d %d", &year, &month, &day))
// {
//	 int total_day = day;
//	 //先把当前月份天数加上 
//	 if (is_leap_year(year) && month > 2)
//	 { //若闰年，且月份大于2月，则在平年基础上+1 
//		 total_day += 1;
//	 }
//	 for (int i = month - 1; i > 0; i--)
//	 {
//		 total_day += month_day[i];
//		 //向前累加每月的天数即可 
//	 }
//	 printf("%d\n", total_day);
// }
 //return 0; }



//8_16
//#include<stdio.h>
//int main()
//{
//	char s[] = "\\123456\123456\t";
//	printf("%d\n", strlen(s));
//	return 0;
//}


//#define N 2
//#define M N + 1
//#define NUM (M + 1) * M / 2          //宏替换是直接替换   //在此式中 ————> （2+1+1）*2+1/2  = 8 
//int main()
//{
//	printf("%d\n", NUM);               //因此结果是8
//	return 0;
//}

//
//int main()
//{
//	char a[14] = "hello world!";
//	printf("%s ", a);
//	char b[14];
//	b = "hello world";
//	printf("%s ", b);
//	return 0;
//}
// 
//int main()
//{
//	double a = 0;
//	if (a == 0.0)
//		printf("yes");
//}


//double类型不能判断是否为0   类似于float类型  近似值

//尼科彻斯定理 
//先找奇数 
//找和 
//int main()
//{
//	int i = 0;
//	int m = 0;
//	int y = 0;
//	int arr[10000] = { 0 };
//	scanf("%d", &m);
//	for (i = 0; i < 10000; i++)//存放奇数到数组中
//	{
//		if (i % 2 == 1)
//		{
//			arr[y] = i;
//			y++;
//		}
//	}
//	int j = 0;
//	int sum = 0;
//	for (j = 0; j < m; j++) //制定奇数开始的位置
//	{
//		sum += j;
//	}
//	for (j = sum; j < sum+m; j++)//打印
//	{
//		printf("%d", arr[j]);
//		if (j < sum + m - 1)
//			printf("+");
//	}
//	return 0;
//}
//int main()  //标答
//{
//	int m;
//	while (~scanf("%d", &m))
//	{
//		int start = m * (m - 1) + 1;
//		//找到对应m^3的起始奇数 
//		char buf[10240] = { 0 };
//		//sprintf(buf, format, ...) 与printf用法类似，格式化字符串但是不用于打印而是放到一个buf中
//		sprintf(buf, "%d", start);
//		//先将起始奇数转换成为字符串存入buf中 
//		for (int i = 1; i < m; i++) {
//			//然后将紧随随后的m-1个奇数数字转换为字符串，按照指定格式放入buf中 
//			//%s+%d, 要求先有一个字符串，然后是+符号，然后是个数字的格式，对应是buf原先的数据，和奇数
//			sprintf(buf, "%s+%d", buf, start += 2);
//		}
//		printf("%s\n", buf);
//	}return 0;
//}


//等差数列求和
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	printf("%d", 2*n + (n*(n-1)*3)/2);
//	return 0;
//}




//           //8_17
//int main()
//{
//	int a = 248, b = 4;
//	int const* c = 21;
//	const int* d = &a;
//	int* const e = &b;
//	int const* const f = &a;
//}



//#include <stdio.h>
//int i;          //全局变量
//void prt()
//{
//	for (i = 5; i < 8; i++)//在主循环i就修改为8了
//		printf("%c", '*');
//	printf("\t");
//} 
//int main()
//{
//	for (i = 5; i <= 8; i++)
//		prt();
//	return 0;
//}


//int main()
//{
//	int a = 3;
//	printf("%d\n", (a += a -= a * a));       //a变化了 注意
//	return 0;
//}



//  记负为正 
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	//输出负数的个数
//	int i = 0;
//	int arr[2000] = { 0 };
//	int count1 = 0;
//	double count2 = 0;
//	double sum = 0;
//	float ave;
//	for (i = 0; i < n; i++)
//	{
//		scanf("%d", &arr[i]);
//		if (arr[i] < 0)
//			count1++;
//		else if (arr[i] > 0)
//		{
//			count2++;
//			sum += arr[i];
//		}
//	}
//	//计算所有正整数的平均值
//	if (count2)
//		ave = sum / count2;
//	//如果全为0
//	if ((count1 == 0) && (count2 == 0))
//		printf("0 0.0");
//	else
//		printf("%d %.1f", count1, ave);
//	return 0;
//}



//旋转数组的最小数字
//int minNumberInRotateArray(int* rotateArray, int rotateArrayLen) {
//    // write code here
//   //先找到变化的地方
//    int i = 0;
//    for (i = 0; i < rotateArrayLen - 1; i++)
//    {
//        if (rotateArray[i] > rotateArray[i + 1])
//            return rotateArray[i + 1];
//    }
//    return rotateArray[0];
//}



//  day   4 
//1、设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是（ ）
//A: n = 0; while (ch = getchar() != '\n')n++; B: n = 0; while (getchar() != '\n')n++;
//C: for (n = 0; getchar() != '\n'; n++); D: n = 0; for (ch = getchar(); ch != '\n'; n++);

//ADescriptor
//int main()
//{
//	char c;
//	int v0 = 0, v1 = 0, v2 = 0;
//		do
//		{
//			switch (c = getchar())
//			{
//			case'a':case'A':
//			case'e':case'E':
//			case'i':case'I':
//			case'o':case'O':
//			case'u':case'U':v1 += 1;
//			default:v0 += 1; v2 += 1;
//			}
//		} while (c != '\n');
//		printf("v0=%d,v1=%d,v2=%d\n", v0, v1, v2);
//		return 0;
//}

//4、以下程序段的功能是（ ）
//A : 对数组a进行插入排序（升序） B : 对数组a进行插入排序（升序） √
//C : 对数组a进行选择排序（升序） D : 对数组a进行选择排序（降序）
//int a[] = { 4, 0, 2, 3, 1 }, i, j, t;
//for (i = 1; i < 5; i++)
//{
//	t = a[i];
//	j = i - 1;
//	while (j >= 0 && t < a[j])
//	{
//		a[j + 1] = a[j];
//		--j;
//	} a
//		[j + 1] = t;
//}



//集合 s 包含从 1 到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个数字复制了成了集合里面的另外一个数字的值，导致集合 丢失了一个数字 并且 有一个数字重复 。
//给定一个数组 nums 代表了集合 S 发生错误后的结果。
//请你找出重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。

//不用函数的方式 草稿
//int main()
//{
//	int arr[3] = { 1,1,3 };
//	//先找到重复的
//	int i = 0;
//	int k = 0;
//	for(i = 0;i<2;i++)
//	{
//
//		if (arr[i] == arr[i + 1])
//		{
//			k = i+1;
//			break;
//		}
//		i++;
//	}
//	//再找到缺失的   替换
//	for (i = 0;i < 2;i++)
//	{
//		if (arr[i] + 1 != arr[i + 1])
//			arr[k] = arr[i] + 1;
//	}
//	int j = 0;
//	for (j = 0; j < 3; j++)
//	{
//		printf("%d", arr[j]);
//	}
//	return 0;
//}
//使用标记的方式就可以找出重复的数字，数组中出现过哪个数字就把对应数字作为下标在对应位置1，表示已经标记
//出现过，如果哪个数据对应位已经置1，则表示就是重复的数字。有了重复的数字，拿[1, n] 的总和减去去掉重复
//数据的数组总和就是丢失的数据。 其实使用标记法时出现的数字对应位每次 ++ ，则最后出现0次的就是丢失，出现2
//次的就是重复的，这样的方式也可以，不过需要多次遍历。





//小明同学最近开发了一个网站，在用户注册账户的时候，需要设置账户的密码，为了加强账户的安全性，小明对密码强度有一定要求：
//1. 密码只能由大写字母，小写字母，数字构成；
//2. 密码不能以数字开头；
//3. 密码中至少出现大写字母，小写字母和数字这三种字符类型中的两种；
//4. 密码长度至少为8
//现在小明受到了n个密码，他想请你写程序判断这些密码中哪些是合适的，哪些是不合法的。
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int flag = 1;
//	int count = 0;
//	int count1 = 0;
//	int count2 = 0;
//	int count3 = 0;
//	int i = 0;
//	char ch[100] = { 0 };
//	for (i = 0; i < n; i++)
//	{
//		scanf("%s", ch);
//
//		//判断开头是否由字母开头
//		if (ch[0] <= '9' && ch[0] >= '0')
//			flag = 0;
//		//判断密码长度
//		int num = strlen(ch);
//		if (num < 8)
//			flag = 0;
//		//密码构成
//		for (i = 0; i < num; i++)
//		{
//			if (!((ch[i] <= '9' && ch[i] >= '0') || (ch[i] <= 'z' && ch[i] >= 'a') || (ch[i] <= 'Z' && ch[i] >= 'A')))
//				flag = 0;
//			if ((ch[i] <= '9' && ch[i] >= '0'))
//				count1++;
//			else if ((ch[i] <= 'z' && ch[i] >= 'a'))
//				count2++;
//			else
//				count3++;
//		}
//		if (count1)
//			count++;
//		if (count2)
//			count++;
//		if (count3)
//			count++;
//		if (count < 2)
//			flag = 0;
//		if (flag == 0)
//			printf("NO");
//		else
//			printf("YES");
//	}
//	return 0;
//}



//day 5 
//int main()
//{
//	int t = 0;
//	while (printf("*"))           //这里的printf("*")  是1  
//		                          //题干中的字符0 也是1
//	{
//		t++;
//		if (t < 3)
//			break;
//	}
//	return 0;
//}
//A: 其中循环控制表达式与0等价 B : 其中循环控制表达式与'0'等价
//C : 其中循环控制表达式是不合法的 D : 以上说法都不对

//给定一个长度为 n 的非降序数组和一个非负数整数 k ，要求统计 k 在数组中出现的次数
//数据范围： 0≤n≤1000, 0≤k≤100 ，数组中每个元素的值满足 0≤val≤100
//int GetNumberOfK(int* data, int dataLen, int k) {
//    // write code here
//    int i = 0;
//    int count = 0;
//    for (i = 0; i < dataLen; i++)
//    {
//        if (data[i] == k)
//            count++;
//    }
//    return count;
//}



//整数转换。编写一个函数，确定需要改变几个位才能将整数 A 转成整数 B 
//int convertInteger(int A, int B) {
//    int count = 0;
//    int i = 0;
//    for (i = 32; i > 0; i--)
//    {
//        if ((A & 1) ^ (B & 1))
//            count++;
//        A >>= 1;
//        B >>= 1;
//    }
//    return count;
//}



//   day  6  
//1、以下叙述中正确的是（ ）
//A : 只能在循环体内和switch语句体内使用break语句    √
//B : 当break出现在循环体中的switch语句体内时，其作用是跳出该switch语句体，并中止循环体的执行  //并进入下一条循环语句的执行
//C : continue语句的作用是：在执行完本次循环体中剩余语句后，中止循环
//D : 在while语句和do - while语句中无法使用continue语句

//int main()
//{
//	int i = 0;
//	for (i = 0; i || i++ < 5;)   //i++小于5 那么此语句为真
//	{
//		printf("hehe");
//	}
//	return 0;
//}


//4、设函数 fun 和实参数组的说明是如下形式，则对函数的调用语句中，正确的是（ ）
//A : fun("asd", a[]); B: fun('x', A); C: fun('68', 2.8); D: fun(32, a);
//int main()
//{
//	char ch = "abd";
//	printf("%c", ch);   //err 
//	return 0;
//}

//在c语言中，一个函数不写返回值类型，默认的返回类型是（ ）           // int
//A : int B : char C : void D : 都不是


//给你一个整数数组 nums ，其中总是存在 唯一的 一个最大整数 。请你找出数组中的最大元素并检查它是否 至
//少是数组中每个其他数字的两倍 。如果是，则返回 最大元素的下标 ，否则返回 - 1 。
//int dominantIndex(int* nums, int numsSize) {
//    int i = 0;
//    int k = 0;
//    int j = 0;
//    int max = 0;
//    int max2 = 0;
//    int arr[101] = { 0 };
//    //找到最大元素
//    for (i = 0; i < numsSize; i++)
//    {
//        if (nums[i] > max)
//        {
//            max = nums[i];
//            k = i;
//        }
//    }
//    //创建新数组
//    for (i = 0; i < numsSize; i++)
//    {
//        if (i == k)
//            continue;
//        arr[j] = nums[i];
//        j++;
//    }
//    //新数组中的最大元素
//    for (i = 0; i < j; i++)
//    {
//        if (arr[i] > max2)
//        {
//            max2 = arr[i];
//        }
//    }
//    if (max < 2 * max2)
//    {
//        return -1;
//    }
//    else
//        return k;
//}
//int main()
//{
//    int nums[4] = { 0,0,2,1 };
//    int numSize = 4;
//   int x =  dominantIndex(nums, numSize);
//   printf("%d", x);
//    return 0;
//}



//day _ 7
//1、以下对C语言函数的有关描述中，正确的有【多选】（ ）
//A : 在C语言中，一个函数一般由两个部分组成，它们是函数首部和函数体
//B : 函数的实参和形参可以是相同的名字
//C : 在main()中定义的变量都可以在其它被调函数中直接使用  //不能
//D : 在C程序中，函数调用不能出现在表达式语句中
//int test(int x)
//{
//	c=
//}
//int main()
//{
//	int a = 10;
//	int c = 20;
//	int b = test(a);
//	return 0;
//}

//在上下文及头文件均正常的情况下，下列代码的输出是（ ）（注： print 已经声明过）
//int  main()
//{
//	char str[] = "Geneius";
//	print(str);
//	return 0;
//}
//print(char* s)
//{
//	if (*s)
//	{
//		print(++s);                        //先++
//		printf("%c", *s);
//	}
//}


//Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。
//Lily使用的图片使用字符"A"到"Z"、"a"到"z"、"0"到"9"表示。
//int cmp(const void* e1, const void* e2)
//{
//    return *(char*)e1 - *(char*)e2;
//}
//int main()
//{
//    char ch[1001] = { 0 };
//    scanf("%s", ch);
//    int len = strlen(ch);
//    int i = 0;
//    qsort(ch, len, sizeof(ch[0]), cmp);
//    printf("%s", ch);
//    return 0;
//}


//给你一个整数数组 nums ，请计算数组的 中心下标 。
//数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
//如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
//如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 - 1 。
//int pivotIndex(int* nums, int numsSize) {
//    //判断中心坐标
//    int i = 0;
//    int j = 0;
//    int k = -1;
//    for (i = 0; i < numsSize; i++)
//    {
//        int sum1 = 0;
//        int sum2 = 0;
//        for (j = 0; j < i; j++)
//        {
//            sum1 += nums[j];
//        }
//        for (j = i + 1; j < numsSize; j++)
//        {
//            sum2 += nums[j];
//        }
//        if (sum1 == sum2)
//        {
//            k = i;
//            break;
//        }
//    }
//    return k;
//}
//int main()
//{
//    int arr[6] = { 1,7,3,6,5,6};
//    int sz = 6;
//    int x = pivotIndex(arr, sz);
//    printf("%d", x);	
//    return 0;
//}



//day_8 
//1、如下程序的运行结果是（ ）
//A : 'a' 'b' B : ab\0c\0 C: ab c D : ab
//char c[5] = { 'a', 'b', '\0', 'c', '\0' };
//printf("%s", c);
//int main()
//{
//	char c[5] = { 'a', 'b', '\0', 'c', '\0' };
//	printf("%s", c);            打印字符串遇到\0停止
//	return 0;
//}

//在下面的字符数组定义中，哪一个有语法错误（ ）
//A: char a[20] = "abcdefg"; B: char a[] = "x+y=5."; C: char a[15]; D: char a[10] = '5';
//int main()
//{
//	char ch[] = "x+t=5.";       //ok
//	printf("%s", ch);
//	char a[10] = '5';         //初始化需要带括号的初始值设定列表
//	//char a[10];          
//	//char a[20] = "abcdef";
//	printf("%s", a);
//
//	return 0;
//}


//已知 i，j 都是整型变量，下列表达式中，与下标引用 X[i][j] 不等效的是【多选】（ ）
//A : *(X[i] + j) B : *(X + i)[j] C : *(X + i + j) D : *(*(X + i) + j)
//int main()
//{
//	int a['10'] = { 0 };
//	return 0;
//}

//int main()
//{
//	int i, j;
//	int x[2][2] = { {1,2},{3,4} };
//	printf("%d", *(x+1)+1);
//	return 0;
//}

//编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
//例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3
//int main()
//{
//    char ch[501] = { 0 };
//    gets(ch);
//    int i = 0;
//    int count = 0;
//    int j = 0;
//    for (i = 0; ch[i] != '\0'; i++)
//    {
//        int flag = 1;
//        for (j = 0; j < i; j++)
//        {
//            if (ch[i] == ch[j])
//                flag = 0;
//        }
//        if (flag)
//            count++;
//    }
//    printf("%d", count);
//    return 0;
//}



// 多数元素
//int* test(const void* e1, const void* e2)
//{
//	return *(int*)e1 - *(int*)e2;
//}
//int majorityElement(int* nums, int numsSize) {
//	qsort(nums, numsSize, sizeof(int), test);
//	return nums[numsSize / 2];
//}
//int main()
//{     
//	int arr[7] = {2,2,1,1,1,2,2};
//	int sz = 7;
//	int x = majorityElement(arr,sz);
//	printf("%d", x);
//	return 0;
//}



//day_9
//1、下列程序的输出是（ ）
//
//int main()
//{
//	int a[12] = { 1,2,3,4,5,6,7,8,9,10,11,12 }, * p[4], i;
//		for (i = 0; i < 4; i++)
//			p[i] = &a[i * 3];
//	printf("%d\n",p[3][2]);       //12
//	return 0;
//} 


//2、二维数组X按行顺序存储，其中每个元素占1个存储单元。若 X[4][4] 的存储地址为 Oxf8b82140, X[9][9] 的存储地
//址为 Oxf8b8221c, 则 X[7][7] 的存储地址为（ ）
//A : Oxf8b821c4 B : Oxf8b821a6 C : Oxf8b82198 D : Oxf8b821c0



//3、以下哪个选项可以正确描述 sizeof(double) （ ）
//A : 一个整型表达式 B : 一个双精度型表达式 C : 一个不合法的表达式 D : 一种函数调用
  //sizeof(float) sizeof(double)都是整形表达式


//int main()
//{
//	char a = 'a', b;
//	printf("%c,", ++a);  // b
//	printf("%c\n", b = a++);  //b
//	return 0;
//}


//5、以下逗号表达式的值为（ ）
//A : 25 B : 20 C : 100 D : 45
//(x = 4 * 5, x * 5), x + 5;      //()中的 x*5 并没有给x 赋值


//自除数
//给定两个整数 left 和 right ，返回一个列表，列表的元素是范围[left, right] 内所有的 自除数 。
//int test(int n)
//{
//    int x = n;
//    while (x > 0)
//    {
//        int m = x % 10;
//        if (m == 0 || n % m != 0) {
//            return 0;
//        }
//        x /= 10;
//    }
//    return 1;
//}
//int* selfDividingNumbers(int left, int right, int* returnSize)
//{
//    int j = 0;
//    int n = 0;
//    int* parr = (int*)malloc(sizeof(int) * (right - left + 1));
//    for (n = left; n <= right; n++)
//    {
//        int x = test(n);
//        if (x)
//        {
//            parr[j++] = n;
//        }
//    }
//    *returnSize = j;
//    return parr;
//}



//给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。
//题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内。

//int main()     //复杂度过高
//{
//    int numsSize = 4;
//    int nums[4] = { 1,2,3,4 };
//    int arr[10] = { 0 };
//    int i = 0;
//    int j = 0;
//    for (i = 0; i < numsSize; i++)
//    {
//        int pr = 1;
//        for (j = 0; j < numsSize; j++)
//        {
//            if (j == i)
//                continue;
//            pr *= nums[j];
//        }
//        arr[i] = pr;
//    }
//    for (i = 0; i < 4; i++)
//    {
//        printf("%d  ", arr[i]);
//    }
//    return arr;
//}








//     day_10
//int func(int x)
//{
//	int count = 0;
//	while (x)
//	{
//		count++;
//		x = x & (x - 1);//与运算
//	} 
//	return count;
//}
//int main()
//{
//	int x = -1;
//	int a = func(x);
//	printf("%d", a);          //32
//	return 0;
//}


//int main()
//{
//	int count = 0;
//	int x = -1;
//	while (x)
//	{
//		count++;
//		x = x >> 1;
//	}
//	printf("%d", count);
//	return 0;
//}



//3、下述赋值语句错误的是（ ）
//A : a = (b = (c = 2, d = 3)) B : i++ C : a / b = 2 D : a = a < a + 1
	                           //a/b 是表达式  表达式计算的是一个值   不能让一个值做左值


//int main()
//{
//	int a = 1, b = 2, m = 0, n = 0, k;
//	k = (n = b < a) && (m = a);   //如果&&前面为假  后面就不判断了
//	printf("%d,%d\n", k, m);
//	return 0;
//}


//不用+-求两个数的和  
//int Add(int num1, int num2)
//{
//	int a = 0;
//	int b = 0;
//	while (num2 != 0)
//	{
//		//不考虑进位
//		a = num1 ^ num2; //0101 0110     0011      
//		//考虑进位
//		b = (num1 & num2) << 1; //0100   1000
//		num1 = a;
//		num2 = b;
//	}
//	return num1;
//}
//int main()
//{
//	int a = 111;
//	int b = 899;
//	int x = Add(a, b);
//	printf("%d", x);
//	return 0;
//}



//找到数组中消失的数字
//int cmp(const void* e1, const void* e2)
//{
//    return *(int*)e1 - *(int*)e2;
//}
//int* findDisappearedNumbers(int* nums, int numsSize, int* returnSize) {
//    int i = 0;
//    int j = 0;
//    *returnSize = 0;
//    int* arr = (int*)malloc(sizeof(int) * numsSize);
//    qsort(nums, numsSize, sizeof(nums[0]), cmp);
//    for (i = 0; i < numsSize; i++)
//    {
//        j = (nums[i] - 1) % numsSize;
//        nums[j] += numsSize;      //这样设置 加数的数字就包含了数组内所有的元素
//    }
//    for (i = 0; i < numsSize; i++)
//    {
//        if (nums[i] <= numsSize)
//            arr[(*returnSize)++] = i + 1;  
//    }
//    return arr;
//}
//int* findDisappearedNumbers(int* nums, int numsSize, int* returnSize) {  //复杂度过大
//    int i = 0;
//    int j = 0;
//    *returnSize = 0;
//    int* arr = (int*)malloc(sizeof(int) * numsSize);
//    // qsort(nums,numsSize,sizeof(nums[0]),cmp);
//    for (i = 0; i < numsSize; i++)
//    {
//        int count = 0;
//        for (j = 0; j < numsSize; j++)
//        {
//            if (i + 1 == nums[j])
//                count++;
//        }
//        if (count == 0)
//            arr[(*returnSize)++] = i + 1;
//    }
//    return arr;
//}



//  day_11
//int main()
//{
//	int x = -1;
//	unsigned int y = 2;
//	if (x > y)
//	{
//		printf("x is greater");  //√
//	} 
//	else
//	{
//	printf("y is greater");
//	} 
//	return 0;
//}


//void func()
//{
//	int x = (1 << 31 >> 31);
//	int k = 1 ^ x;
//	printf("%d\n", k);       //111111110  补码  111111101   反码   100000010   原码
//}
//int main()
//{
//	func();
//	return 0;
//}



//int main()
//{
//	int i = 1;
//	sizeof(i++);      //直接跳过   sizeof是操作符 还没编译就已经出来结果了
//	printf("%d\n", i);
//	return 0;
//}



//最大连续1的个数
//、给定一个二进制数组， 计算其中最大连续 1 的个数。
//int findMaxConsecutiveOnes(int* nums, int numsSize) {
//    int count = 0;
//    int max = 0;
//    int i = 0;
//    for (i = 0; i < numsSize; i++)
//    {
//        if (nums[i] == 1)
//        {
//            count++;
//        }
//        if (nums[i] == 0)
//        {
//            count = 0;
//        }
//        if (count > max)
//            max = count;
//    }
//    return max;
//}
//int main()
//{
//    int arr[6] = {1,0,1,1,0,1};
//    int sz = 6;
//    int x = findMaxConsecutiveOnes(arr,sz);
//    printf("%d", x);
//    return 0;
//}
//


//求出n以内的完全数  除自身外所有因子之和即为本身
//int main()
//{
//	//先求出约数 
//	int i ,j,n,count=0;
//	scanf("%d", &n);
//	for (j = 1; j < n; j++)
//	{
//		int sum = 0;
//		for (i = 1; i <= j; i++)
//		{
//			if (j % i == 0)
//			{
//				if (i != j)
//				{
//					sum += i;
//				}
//			}
//		}
//		if (sum == j)
//			count++;
//	}
//	printf("%d", count);
//	return 0;
//}



//  day_12
//int main()
//{
//	char c = 'A';
//	if ('0' <= c <= '9') printf("YES");  //这里前面无论是符合大于等于 还是不符合 输出的结果都会是1或者0  进而比较的就是0/1和 '9'比较
//	else printf("NO");
//	return 0;
//}



//int main()
//{
//	int n = 1001;
//	int ans = 0;
//	for (int i = 1; i <= n; ++i)
//	{
//		ans ^= i % 3;
//	}
//	printf("%d", ans);  //0
//	return 0;
//}


//4、C 语言中，下列运算符优先级最高的是()
//A: !B : % C : >> D : == 
//优先顺序 ：  !  %  >>  == 


//数字颠倒
// 1、输入一个整数，将这个整数以字符串的形式逆序输出，程序不考虑负数的情况，若数字含有0，则逆序形式也含
//有0，如输入为100，则输出为001。
//int main()
//{
//    int n = 1516000;
//    int i = 0;
//    char c[25];
//    //先把int类型转换成字符的形式
//    _itoa(n, c, 10);        //第一个参数是数字  第二个参数是替换的数组 第三个参数是基数10
//    printf("%s\n", c);
//    int x = strlen(c);
//    for (i = 0; i < x/2; i++)
//    {
//        char tmp= 0;
//        tmp = c[i];
//        c[i] = c[x - 1 - i];
//        c[x - 1 - i] = tmp;
//    }
//    printf("%s\n", c);
//    return 0;
//}
//int main()
//{
//	//先把数字转换成字符
//	int a = 0;
//	scanf("%d", &a);
//	char c[1001] = { 0 };
//	int i = 0;
//	int n = a;
//	if (n == 0)
//		c[0] = '0';
//	while (n > 0)
//	{
//		c[i++] = (n % 10) + '0';
//		n /= 10;
//	}
//	printf("%s", c);
//	return 0;
//}



//对字符串的单词颠倒
//void clang(char* left, char* right)
//{
//	while (left < right)
//	{
//		char tmp = 0;
//		tmp = *left;
//		*left = *right;
//		*right = tmp;
//		left++;
//		right--;
//	}
//}
//int main()
//{
//	int i = 0;
//	char c[10000] = { 0 };
//	gets(c);
//	int len = strlen(c);
//	char* start = c;
//	//先进行一次整体倒置
//	clang(c, c + len - 1);
//	//核检对是否符合要求的字符
//	for (i = 0; i < len; i++)
//	{
//		if (!((c[i] >= 'a' && c[i] <= 'z') || (c[i] >= 'A' && c[i] <= 'Z')))
//			if (c[i - 1] != ' ')
//				c[i] = ' ';
//	}
//	//局部倒置
//	while (*start)
//	{
//		char* end = start;
//		while (*end != ' ' && *end != '\0')
//		{
//			end++;
//		}
//		clang(start, end - 1);
//		if (*end != '0')
//		{
//			start = end + 1;
//		}
//		else
//		{
//			start = end;
//		}
//	}
//	printf("%s", c);
//	return 0;
//}
//





// day_13
//int fun(unsigned int x)
//{
//	int n = 0;
//	while (x + 1)
//	{
//		n++;
//		x = x | (x + 1);
//	} 
//	return n;  //23
//}

//3、下面有关空指针和未初始化指针，说法错误的是（ ）
//A : 对0x0这个地址取值是非法的
//B : 空指针可以确保不指向任何对象或函数; 而未初始化指针则可能指向任何地方
//C : 空指针与任何对象或函数的指针值都不相等
//D : malloc在其内存分配失败时返回的是一个未初始化的指针       //返回的是一个NULL指针





//5、以下选项中，对基本类型相同的两个指针变量不能进行运算的运算符是（ ）  //两个指针相加没有意义
//A : +B : -C : = D : ==


//有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
//例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。
//一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少
//int test(int x)
//{
//	while (x > 3)
//	{
//		return test(x - 1) + test(x - 2);
//	}
//	if (x == 3)
//		return 2;
//	else
//		return 1;
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int count = 0;
//	count = test(n);
//	printf("%d", count);
//	return 0;
//}


//2、数列的定义如下：数列的第一项为n，以后各项为前一项的平方根，求数列的前m项的和。
//输入数据有多组，每组占一行，由两个整数 n(n < 10000) 和 m(m < 1000) 组成，n和m的含义如前所述。
//	对于每组输入数据，输出该数列的和，每个测试实例占一行，要求精度保留2位小数。
//int main()
//{
//	double arr[10001] = { 0 };
//	int n = 0;
//	int m = 0;
//	while (scanf("%d%d", &n,&m) != EOF)
//	{
//		int i = 0;
//		double sum = 0;
//		//先编辑输入数组的每一项
//		for (i = 0; i < m; i++)//4用m代替
//		{
//			if (i > 0)
//				arr[i] = sqrt(arr[i - 1]);
//			else
//				arr[i] = n;
//			//求和输出
//			sum += arr[i];
//		}
//		printf("%.2f\n", sum);
//	}
//	return 0;
//}



//day_14
//int fun(char* s)
//{
//	char* t = s;
//	while (*t++);//先跟++结合  但是后置++  //返回所占字节空间
//	return(t - s);
//}
//int main()
//{
//	char c[] = "abcd";
//	int x = fun(c);
//	printf("%d", x);
//	return 0;
//}


//int main()
//{
//	float a[3] = { 1.5,2.5,3.5 }, * pa = a;
//	*(pa++) *= 3;
//	printf("%.1f", *pa);//2.5
//}


//int main()
//{
//	int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }, * p = a + 5, * q = NULL;
//	*q = *(p + 5);           // 会报错   NULL不能解引用
//	printf("%d %d\n", *p, *q);
//	return 0;
//}



//5、以下叙述中正确的是（ ）
//A : 即使不进行强制类型转换，在进行指针赋值运算时，指针变量的基类型也可以不同       //指针只能赋值地址 否则会出错
//B : 如果企图通过一个空指针来访问一个存储单元，将会得到一个出错信息  
//C : 设变量p是一个指针变量，则语句p = 0; 是非法的，应该使用p = NULL;         //p=0 等效于 p= NULL
//D: 指针变量之间不能用关系运算符进行比较            //err    //可以比较  比较的意义是看指向位置的高低
//int main()
//{
//	int b = 0;
//	int* a = &a;
//	a = NULL;
//	a = 0;//不非法
//	return 0;
//}


//珠玑妙算游戏（the game of master mind
//int* masterMind(char* solution, char* guess, int* returnSize) {
//    int x1, x2, x3, x4, x5, x6, x7, x8;
//    x1 = x2 = x3 = x4 = x5 = x6 = x7 = x8 = 0;
//    int i = 0;
//    int count = 0;
//    for (i = 0; i < 4; i++)
//    {
//        switch (solution[i])
//        {
//        case 'R':
//            x1++;
//            break;
//        case 'Y':
//            x2++;
//            break;
//        case 'G':
//            x3++;
//            break;
//        case 'B':
//            x4++;
//            break;
//        }
//    }
//    for (i = 0; i < 4; i++)
//    {
//        switch (guess[i])
//        {
//        case 'R':
//            x5++;
//            break;
//        case 'Y':
//            x6++;
//            break;
//        case 'G':
//            x7++;
//            break;
//        case 'B':
//            x8++;
//            break;
//        }
//    }
//    int n1 = x1 < x5 ? x1 : x5;
//    int n2 = x2 < x6 ? x2 : x6;
//    int n3 = x3 < x7 ? x3 : x7;
//    int n4 = x4 < x8 ? x4 : x8;
//    int ALLtimes = n1 + n2 + n3 + n4;
//    for (i = 0; i < 4; i++)
//    {
//        if (solution[i] == guess[i])
//            count++;
//    }
//    ALLtimes -= count;
//    //设计结果数组
//    int* arr = (int*)malloc(sizeof(int) * 4);
//    *returnSize = 2;
//    arr[0] = count;
//    arr[1] = ALLtimes;
//    return arr;
//}


//给出一个整型数组 numbers 和一个目标值 target，请在数组中找出两个加起来等于目标值的数的下标，返回的下标按升序排列。
//（注：返回的数组下标从1开始算起，保证target一定可以由数组里面2个数字相加得到）
//int* twoSum(int* numbers, int numbersLen, int target, int* returnSize) {
//    // write code here
//    //创建结果数组
//    int* returnnumbers = (int*)malloc(sizeof(int) * numbersLen);
//    *returnSize = 2;
//
//    int i = 0;
//    int j = 0;
//    for (i = 0; i < numbersLen; i++)
//    {
//        if (numbers[i] > target + 10)
//            continue;
//        for (j = i; j < numbersLen; j++)
//        {
//            if ((numbers[j] > target + 10) || (i == j))
//                continue;
//            if (numbers[i] + numbers[j] == target)
//            {
//                returnnumbers[0] = i + 1;
//                returnnumbers[1] = j + 1;
//            }
//        }
//    }
//    //下标按升序排列
//    //qsort(returnnumbers,*returnSize,sizeof(int),cmp);
//    return returnnumbers;
//}



//补充  ：   
//两个字符串的比较
//思路：对t中元素遍历，并与s中当前待比较元素比较。
//实现：用代表s中当前待比较元素的下标。
//int is_sub(char* s, char* t) {
//    int lent = strlen(t), lens = strlen(s);
//    int i = 0;
//    for (int j = 0; j < lent; ++j) {
//        if (t[j] == s[i]) ++i;
//        if (i == lens) return 1;
//    }
//    return 0;
//}




//day _15
// A: 任何指针都可以转化为void * B: void *可以转化为任何指针
//C: 指针的大小为8个字节 D : 指针虽然高效、灵活但可能不安全
// c:err 可能为4个字节

//struct T
//{
//	char name[20];
//	int age;
//	int sex;
//} a[5], * pa = a;
//int main()
//{
//	scanf("%d", &pa[0].age); 
//	scanf("%s", a[0].name);
//	scanf("%d", &(pa->age));
//	scanf("%d", pa->age);//err
//	return 0;
//}


//4、如下函数 fun 计算 prod = 1 * 2 * 3 * … * n ，并返回计算结果值。但当 n > 12 时，返回值不正确。要找出该程序的错
//误，正确的调试方法是（ ）
//int fun(int n)
//{
//	int prod = 1, i = 0;
//	for (i = 1; i <= n; i++)
//	{
//		prod *= i;     //监测这里  数据过大 整形溢出
//	} 
//	return prod;
//}
//int main()
//{
//	int a = 13;
//	int x = fun(a);
//	printf("%d", x);
//	return 0;
//}

//现在有一个长度为 n 的正整数序列，其中只有一种数值出现了奇数次，其他数值均出现偶数次，请你找出那个出现奇数次的数值
//第一行：一个整数n，表示序列的长度。第二行：n个正整数ai，两个数中间以空格隔开。
//一个数，即在序列中唯一出现奇数次的数值。
//int main()
//{
//    int i = 0;
//    int n = 0;
//    int end = 0;
//    int tmp = 0;
//    scanf("%d", &n);
//    for (i = 0; i < n; i++)
//    {
//        scanf("%d", &tmp);
//        end = tmp ^ end;
//    }
//    printf("%d\n", end);
//    return 0;
//}



//寻找峰值  //简单的二分查找
//https://www.nowcoder.com/practice/fcf87540c4f347bcb4cf720b5b350c76?tpId=188&&tqId=38666&rp=1&ru=/activity/oj&qru=/ta/job-code-high-week/question-ranking
//int findPeakElement(int* nums, int numsLen) {
//    // write code here
//    int left = 0;
//    int right = numsLen - 1;
//    while (left < right)
//    {
//        int mid = (left + right) / 2;
//        if (nums[mid] < nums[mid + 1])
//            left = mid+1;
//        else
//            right = mid;
//    }
//    return left;
//}
//int main()
//{
//    int arr[7] = { 2, 4, 1, 2, 7, 8, 4 };
//    int sz = 7;
//    int x = findPeakElement(arr,sz);
//    printf("%d", x);
//    return 0;
//}


// day_16
//float f[10];
//// 假设这里有对f进行初始化的代码
//for (int i = 0; i < 10;)
//{
//	if (f[++i] == 0)          //err   后置++     而且浮点数不能用==比较 浮点数相当于近似值 会出现精度上的误差
//		break;
//}

//void GetMemory(char** p, int num)
//{
//	if (NULL == p && num <= 0)//1                //这里应该用||
//		return;
//	*p = (char*)malloc(num);
//	return;
//}
//int main()
//{
//	char* str = NULL;
//	GetMemory(&str, 80); //2
//	if (NULL != str)
//	{
//		strcpy(&str, "hello"); //3            //这里应该用copy
//		printf(str); //4
//	}
//}

//typedef union
//{
//	int a;
//	struct
//	{
//		short b;
//		short c;
//	};
//}X;
//int main()
//{
//	X x;
//	x.a = 0x20150810;
//	printf("%x,%x\n", x.b, x.c); //810  2015
//	//%x  读入十六进制整数
//	return 0;
//}


//#define MAX 255
//int main()
//{
//	unsigned char A[MAX], i;
//	for (i = 0; i <= MAX; i++)  //数据越界 死循环
//		A[i] = i;
//	return 0;
//}


//int main()
//{
//	unsigned char i = 7;  //注意是字符   范围255  ASCII码值上的0
//	int j = 0;
//	for (; i > 0; i -= 3)
//	{
//		++j;
//	}
//	printf("%d\n", j);    //173
//	return 0;
//}


//寻找符合余数要求的对数
//int main()
//{
//    long n, k = 0;
//    scanf("%ld%ld", &n, &k);
//    long count = 0;
//    if (k == 0)
//    {
//        printf("%ld", n * n);
//    }
//    else
//    {
//        for (long y = k + 1; y <= n; y++)
//        {
//
//            long ret = n % y < k ? 0 : n % y - k + 1;
//            count += (y - k) * (n / y) + ret;
//        }
//        printf("%ld", count);
//    }
//    return 0;
//}